{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-02T08:31:44.936725Z",
     "start_time": "2024-05-02T08:31:40.034353600Z"
    },
    "execution": {
     "iopub.execute_input": "2025-02-04T02:57:34.053188Z",
     "iopub.status.busy": "2025-02-04T02:57:34.053025Z",
     "iopub.status.idle": "2025-02-04T02:57:36.157591Z",
     "shell.execute_reply": "2025-02-04T02:57:36.157064Z",
     "shell.execute_reply.started": "2025-02-04T02:57:34.053161Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
      "  from .autonotebook import tqdm as notebook_tqdm\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sys.version_info(major=3, minor=10, micro=14, releaselevel='final', serial=0)\n",
      "matplotlib 3.10.0\n",
      "numpy 1.26.4\n",
      "pandas 2.2.3\n",
      "sklearn 1.6.0\n",
      "torch 2.5.1+cu124\n",
      "cuda:0\n"
     ]
    }
   ],
   "source": [
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import numpy as np\n",
    "import sklearn\n",
    "import pandas as pd\n",
    "import os\n",
    "import sys\n",
    "import time\n",
    "from tqdm.auto import tqdm\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "print(sys.version_info)\n",
    "for module in mpl, np, pd, sklearn, torch:\n",
    "    print(module.__name__, module.__version__)\n",
    "    \n",
    "device = torch.device(\"cuda:0\") if torch.cuda.is_available() else torch.device(\"cpu\")\n",
    "print(device)\n",
    "\n",
    "seed = 42\n",
    "torch.manual_seed(seed)\n",
    "torch.cuda.manual_seed_all(seed)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 准备数据"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-02T08:32:04.220762800Z",
     "start_time": "2024-05-02T08:31:48.083348400Z"
    },
    "execution": {
     "iopub.execute_input": "2025-02-04T02:57:36.159257Z",
     "iopub.status.busy": "2025-02-04T02:57:36.158737Z",
     "iopub.status.idle": "2025-02-04T02:57:41.090252Z",
     "shell.execute_reply": "2025-02-04T02:57:41.089687Z",
     "shell.execute_reply.started": "2025-02-04T02:57:36.159235Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2025-02-04 10:57:36.307664: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n",
      "2025-02-04 10:57:36.319112: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:477] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n",
      "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n",
      "E0000 00:00:1738637856.333515     910 cuda_dnn.cc:8310] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n",
      "E0000 00:00:1738637856.337932     910 cuda_blas.cc:1418] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n",
      "2025-02-04 10:57:36.352566: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n",
      "To enable the following instructions: AVX2 AVX512F AVX512_VNNI FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n"
     ]
    }
   ],
   "source": [
    "from tensorflow import keras\n",
    "#用karas有的数据集imdb，电影分类,分电影是积极的，还是消极的\n",
    "imdb = keras.datasets.imdb\n",
    "#载入数据使用下面两个参数\n",
    "vocab_size = 10000  #词典大小，仅保留训练数据中前10000个最经常出现的单词，低频单词被舍弃\n",
    "index_from = 3  #0,1,2,3空出来做别的事\n",
    "#前一万个词出现词频最高的会保留下来进行处理，后面的作为特殊字符处理，\n",
    "# 小于3的id都是特殊字符，下面代码有写\n",
    "# 需要注意的一点是取出来的词表还是从1开始的，需要做处理\n",
    "(train_data, train_labels), (test_data, test_labels) = imdb.load_data(\n",
    "    num_words = vocab_size, index_from = index_from)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-02T08:32:14.425129500Z",
     "start_time": "2024-05-02T08:32:14.402142900Z"
    },
    "execution": {
     "iopub.execute_input": "2025-02-04T02:57:41.091909Z",
     "iopub.status.busy": "2025-02-04T02:57:41.091293Z",
     "iopub.status.idle": "2025-02-04T02:57:41.094897Z",
     "shell.execute_reply": "2025-02-04T02:57:41.094436Z",
     "shell.execute_reply.started": "2025-02-04T02:57:41.091879Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train 25000 (25000,)\n",
      "test 25000 (25000,)\n"
     ]
    }
   ],
   "source": [
    "\n",
    "print(\"train\", len(train_data), train_labels.shape)  #25000个样本，每个样本是一段话，每个单词用一个数字表示\n",
    "print(\"test\", len(test_data), test_labels.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-02T08:32:17.066012200Z",
     "start_time": "2024-05-02T08:32:16.837139900Z"
    },
    "execution": {
     "iopub.execute_input": "2025-02-04T02:57:41.095887Z",
     "iopub.status.busy": "2025-02-04T02:57:41.095525Z",
     "iopub.status.idle": "2025-02-04T02:57:41.134885Z",
     "shell.execute_reply": "2025-02-04T02:57:41.134427Z",
     "shell.execute_reply.started": "2025-02-04T02:57:41.095867Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "88584\n",
      "<class 'dict'>\n"
     ]
    }
   ],
   "source": [
    "#载入词表，看下词表长度，词表就像英语字典\n",
    "word_index = imdb.get_word_index()\n",
    "print(len(word_index))\n",
    "print(type(word_index))\n",
    "#词表虽然有8万多，但是我们只载入了最高频的1万词！！！！"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 构造 word2idx 和 idx2word"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-02T08:32:20.506027300Z",
     "start_time": "2024-05-02T08:32:20.420076700Z"
    },
    "execution": {
     "iopub.execute_input": "2025-02-04T02:57:41.135754Z",
     "iopub.status.busy": "2025-02-04T02:57:41.135467Z",
     "iopub.status.idle": "2025-02-04T02:57:41.163836Z",
     "shell.execute_reply": "2025-02-04T02:57:41.163372Z",
     "shell.execute_reply.started": "2025-02-04T02:57:41.135734Z"
    }
   },
   "outputs": [],
   "source": [
    "word2idx = {word: idx + 3 for word, idx in word_index.items()}\n",
    "word2idx.update({\n",
    "    \"[PAD]\": 0,     # 填充 token\n",
    "    \"[BOS]\": 1,     # begin of sentence\n",
    "    \"[UNK]\": 2,     # 未知 token\n",
    "    \"[EOS]\": 3,     # end of sentence\n",
    "})\n",
    "\n",
    "idx2word = {idx: word for word, idx in word2idx.items()}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-02-04T02:57:41.164596Z",
     "iopub.status.busy": "2025-02-04T02:57:41.164401Z",
     "iopub.status.idle": "2025-02-04T02:57:42.146446Z",
     "shell.execute_reply": "2025-02-04T02:57:42.145940Z",
     "shell.execute_reply.started": "2025-02-04T02:57:41.164576Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 选择 max_length\n",
    "length_collect = {}\n",
    "for text in train_data:\n",
    "    length = len(text)\n",
    "    length_collect[length] = length_collect.get(length, 0) + 1\n",
    "    \n",
    "MAX_LENGTH = 500\n",
    "plt.bar(length_collect.keys(), length_collect.values())\n",
    "plt.axvline(MAX_LENGTH, label=\"max length\", c=\"gray\", ls=\":\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tokenizer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-02T08:32:28.841714100Z",
     "start_time": "2024-05-02T08:32:28.818725300Z"
    },
    "execution": {
     "iopub.execute_input": "2025-02-04T02:57:42.148748Z",
     "iopub.status.busy": "2025-02-04T02:57:42.148289Z",
     "iopub.status.idle": "2025-02-04T02:57:42.159309Z",
     "shell.execute_reply": "2025-02-04T02:57:42.158830Z",
     "shell.execute_reply.started": "2025-02-04T02:57:42.148727Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "raw text\n",
      "['hello', 'world']\n",
      "['tokenize', 'text', 'datas', 'with', 'batch']\n",
      "['this', 'is', 'a', 'test']\n",
      "indices\n",
      "tensor([   0,    0,    0,    1, 4825,  182,    3])\n",
      "tensor([    1,     2,  3004,     2,    19, 19233,     3])\n",
      "tensor([   0,    1,   14,    9,    6, 2181,    3])\n",
      "decode text\n",
      "[PAD] [PAD] [PAD] [BOS] hello world [EOS]\n",
      "[BOS] [UNK] text [UNK] with batch [EOS]\n",
      "[PAD] [BOS] this is a test [EOS]\n"
     ]
    }
   ],
   "source": [
    "class Tokenizer:\n",
    "    def __init__(self, word2idx, idx2word, max_length=500, pad_idx=0, bos_idx=1, eos_idx=3, unk_idx=2):\n",
    "        self.word2idx = word2idx\n",
    "        self.idx2word = idx2word\n",
    "        self.max_length = max_length\n",
    "        self.pad_idx = pad_idx\n",
    "        self.bos_idx = bos_idx\n",
    "        self.eos_idx = eos_idx\n",
    "        self.unk_idx = unk_idx\n",
    "    \n",
    "    def encode(self, text_list, padding_first=False):\n",
    "        \"\"\"如果padding_first == True，则padding加载前面，否则加载后面\"\"\"\n",
    "        max_length = min(self.max_length, 2 + max([len(text) for text in text_list]))\n",
    "        indices_list = []\n",
    "        for text in text_list:\n",
    "            indices = [self.bos_idx] + [self.word2idx.get(word, self.unk_idx) for word in text[:max_length-2]] + [self.eos_idx]\n",
    "            if padding_first:\n",
    "                indices = [self.pad_idx] * (max_length - len(indices)) + indices\n",
    "            else:\n",
    "                indices = indices + [self.pad_idx] * (max_length - len(indices))\n",
    "            indices_list.append(indices)\n",
    "        return torch.tensor(indices_list)\n",
    "    \n",
    "    \n",
    "    def decode(self, indices_list, remove_bos=True, remove_eos=True, remove_pad=True, split=False):\n",
    "        text_list = []\n",
    "        for indices in indices_list:\n",
    "            text = []\n",
    "            for index in indices:\n",
    "                word = self.idx2word.get(index, \"[UNK]\")\n",
    "                if remove_bos and word == \"[BOS]\":\n",
    "                    continue\n",
    "                if remove_eos and word == \"[EOS]\":\n",
    "                    break\n",
    "                if remove_pad and word == \"[PAD]\":\n",
    "                    break\n",
    "                text.append(word)\n",
    "            text_list.append(\" \".join(text) if not split else text)\n",
    "        return text_list\n",
    "    \n",
    "\n",
    "tokenizer = Tokenizer(word2idx=word2idx, idx2word=idx2word)\n",
    "raw_text = [\"hello world\".split(), \"tokenize text datas with batch\".split(), \"this is a test\".split()]\n",
    "indices = tokenizer.encode(raw_text, padding_first=True)\n",
    "decode_text = tokenizer.decode(indices.tolist(), remove_bos=False, remove_eos=False, remove_pad=False)\n",
    "print(\"raw text\")\n",
    "for raw in raw_text:\n",
    "    print(raw)\n",
    "print(\"indices\")\n",
    "for index in indices:\n",
    "    print(index)\n",
    "print(\"decode text\")\n",
    "for decode in decode_text:\n",
    "    print(decode)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-02-04T02:57:42.159983Z",
     "iopub.status.busy": "2025-02-04T02:57:42.159805Z",
     "iopub.status.idle": "2025-02-04T02:57:42.164307Z",
     "shell.execute_reply": "2025-02-04T02:57:42.163746Z",
     "shell.execute_reply.started": "2025-02-04T02:57:42.159964Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[\"[BOS] this film was just brilliant casting location scenery story direction everyone's really suited the part they played and you could just imagine being there robert [UNK] is an amazing actor and now the same being director [UNK] father came from the same scottish island as myself so i loved the fact there was a real connection with this film the witty remarks throughout the film were great it was just brilliant so much that i bought the film as soon as it was released for [UNK] and would recommend it to everyone to watch and the fly fishing was amazing really cried at the end it was so sad and you know what they say if you cry at a film it must have been good and this definitely was also [UNK] to the two little boy's that played the [UNK] of norman and paul they were just brilliant children are often left out of the [UNK] list i think because the stars that play them all grown up are such a big profile for the whole film but these children are amazing and should be praised for what they have done don't you think the whole story was so lovely because it was true and was someone's life after all that was shared with us all\",\n",
       " \"[BOS] big hair big boobs bad music and a giant safety pin these are the words to best describe this terrible movie i love cheesy horror movies and i've seen hundreds but this had got to be on of the worst ever made the plot is paper thin and ridiculous the acting is an abomination the script is completely laughable the best is the end showdown with the cop and how he worked out who the killer is it's just so damn terribly written the clothes are sickening and funny in equal [UNK] the hair is big lots of boobs [UNK] men wear those cut [UNK] shirts that show off their [UNK] sickening that men actually wore them and the music is just [UNK] trash that plays over and over again in almost every scene there is trashy music boobs and [UNK] taking away bodies and the gym still doesn't close for [UNK] all joking aside this is a truly bad film whose only charm is to look back on the disaster that was the 80's and have a good old laugh at how bad everything was back then\"]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 看看训练集的数据\n",
    "\n",
    "tokenizer.decode(train_data[:2], remove_bos=False, remove_eos=False, remove_pad=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 数据集与 DataLoader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-02T08:32:41.820591900Z",
     "start_time": "2024-05-02T08:32:36.227566100Z"
    },
    "execution": {
     "iopub.execute_input": "2025-02-04T02:57:42.165012Z",
     "iopub.status.busy": "2025-02-04T02:57:42.164835Z",
     "iopub.status.idle": "2025-02-04T02:57:45.496922Z",
     "shell.execute_reply": "2025-02-04T02:57:45.496381Z",
     "shell.execute_reply.started": "2025-02-04T02:57:42.164994Z"
    }
   },
   "outputs": [],
   "source": [
    "from torch.utils.data import Dataset, DataLoader\n",
    "\n",
    "class IMDBDataset(Dataset):\n",
    "    def __init__(self, data, labels, remain_length=True):\n",
    "        if remain_length:\n",
    "            self.data = tokenizer.decode(data, remove_bos=False, remove_eos=False, remove_pad=False)\n",
    "        else:\n",
    "            # 缩减一下数据\n",
    "            self.data = tokenizer.decode(data)\n",
    "        self.labels = labels\n",
    "    \n",
    "    def __getitem__(self, index):\n",
    "        text = self.data[index]\n",
    "        label = self.labels[index]\n",
    "        return text, label\n",
    "    \n",
    "    def __len__(self):\n",
    "        return len(self.data)\n",
    "    \n",
    "    \n",
    "def collate_fct(batch):\n",
    "    text_list = [item[0].split() for item in batch]\n",
    "    label_list = [item[1] for item in batch]\n",
    "    # 这里使用 padding first\n",
    "    text_list = tokenizer.encode(text_list, padding_first=True).to(dtype=torch.int)\n",
    "    return text_list, torch.tensor(label_list).reshape(-1, 1).to(dtype=torch.float)\n",
    "\n",
    "\n",
    "# 用RNN，缩短序列长度\n",
    "train_ds = IMDBDataset(train_data, train_labels, remain_length=False)\n",
    "test_ds = IMDBDataset(test_data, test_labels, remain_length=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-02T08:33:12.220977300Z",
     "start_time": "2024-05-02T08:33:12.195716900Z"
    },
    "execution": {
     "iopub.execute_input": "2025-02-04T02:57:45.497809Z",
     "iopub.status.busy": "2025-02-04T02:57:45.497550Z",
     "iopub.status.idle": "2025-02-04T02:57:45.501322Z",
     "shell.execute_reply": "2025-02-04T02:57:45.500706Z",
     "shell.execute_reply.started": "2025-02-04T02:57:45.497788Z"
    }
   },
   "outputs": [],
   "source": [
    "batch_size = 128\n",
    "train_dl = DataLoader(train_ds, batch_size=batch_size, shuffle=True, collate_fn=collate_fct)\n",
    "test_dl = DataLoader(test_ds, batch_size=batch_size, shuffle=False, collate_fn=collate_fct)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 定义模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-02T08:33:48.336669800Z",
     "start_time": "2024-05-02T08:33:48.283700100Z"
    },
    "execution": {
     "iopub.execute_input": "2025-02-04T02:57:45.502010Z",
     "iopub.status.busy": "2025-02-04T02:57:45.501840Z",
     "iopub.status.idle": "2025-02-04T02:57:45.515092Z",
     "shell.execute_reply": "2025-02-04T02:57:45.514620Z",
     "shell.execute_reply.started": "2025-02-04T02:57:45.501991Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "================================== 一层单向 LSTM ===================================\n",
      "            embeding.weight             paramerters num: 160000\n",
      "           lstm.weight_ih_l0            paramerters num: 4096\n",
      "           lstm.weight_hh_l0            paramerters num: 16384\n",
      "            lstm.bias_ih_l0             paramerters num: 256\n",
      "            lstm.bias_hh_l0             paramerters num: 256\n",
      "              layer.weight              paramerters num: 4096\n",
      "               layer.bias               paramerters num: 64\n",
      "               fc.weight                paramerters num: 64\n",
      "                fc.bias                 paramerters num: 1\n",
      "================================== 一层双向 LSTM ===================================\n",
      "            embeding.weight             paramerters num: 160000\n",
      "           lstm.weight_ih_l0            paramerters num: 4096\n",
      "           lstm.weight_hh_l0            paramerters num: 16384\n",
      "            lstm.bias_ih_l0             paramerters num: 256\n",
      "            lstm.bias_hh_l0             paramerters num: 256\n",
      "       lstm.weight_ih_l0_reverse        paramerters num: 4096\n",
      "       lstm.weight_hh_l0_reverse        paramerters num: 16384\n",
      "        lstm.bias_ih_l0_reverse         paramerters num: 256\n",
      "        lstm.bias_hh_l0_reverse         paramerters num: 256\n",
      "              layer.weight              paramerters num: 8192\n",
      "               layer.bias               paramerters num: 64\n",
      "               fc.weight                paramerters num: 64\n",
      "                fc.bias                 paramerters num: 1\n",
      "================================== 两层单向 LSTM ===================================\n",
      "            embeding.weight             paramerters num: 160000\n",
      "           lstm.weight_ih_l0            paramerters num: 4096\n",
      "           lstm.weight_hh_l0            paramerters num: 16384\n",
      "            lstm.bias_ih_l0             paramerters num: 256\n",
      "            lstm.bias_hh_l0             paramerters num: 256\n",
      "           lstm.weight_ih_l1            paramerters num: 16384\n",
      "           lstm.weight_hh_l1            paramerters num: 16384\n",
      "            lstm.bias_ih_l1             paramerters num: 256\n",
      "            lstm.bias_hh_l1             paramerters num: 256\n",
      "              layer.weight              paramerters num: 4096\n",
      "               layer.bias               paramerters num: 64\n",
      "               fc.weight                paramerters num: 64\n",
      "                fc.bias                 paramerters num: 1\n"
     ]
    }
   ],
   "source": [
    "class LSTM(nn.Module):\n",
    "    def __init__(self, embedding_dim=16, hidden_dim=64, vocab_size=vocab_size, num_layers=1, bidirectional=False):\n",
    "        super(LSTM, self).__init__()\n",
    "        self.embeding = nn.Embedding(vocab_size, embedding_dim)\n",
    "        self.lstm = nn.LSTM(embedding_dim, hidden_dim, num_layers=num_layers, batch_first=True, bidirectional=bidirectional)\n",
    "        self.layer = nn.Linear(hidden_dim * (2 if bidirectional else 1), hidden_dim)\n",
    "        self.fc = nn.Linear(hidden_dim, 1)\n",
    "        \n",
    "    def forward(self, x):\n",
    "        # [bs, seq length]\n",
    "        x = self.embeding(x)\n",
    "        # [bs, seq length, embedding_dim] -> shape [bs, embedding_dim, seq length]\n",
    "        seq_output, (hidden, cell) = self.lstm(x)\n",
    "        # [bs, seq length, hidden_dim], [*, bs, hidden_dim]\n",
    "        x = seq_output[:, -1, :]\n",
    "        # 取最后一个时间步的输出 (这也是为什么要设置padding_first=True的原因)\n",
    "        x = self.layer(x)\n",
    "        x = self.fc(x)\n",
    "        return x\n",
    "    \n",
    "sample_inputs = torch.randint(0, vocab_size, (2, 128))\n",
    "    \n",
    "print(\"{:=^80}\".format(\" 一层单向 LSTM \"))       \n",
    "for key, value in LSTM().named_parameters():\n",
    "    print(f\"{key:^40}paramerters num: {np.prod(value.shape)}\")\n",
    "\n",
    "    \n",
    "print(\"{:=^80}\".format(\" 一层双向 LSTM \"))       \n",
    "for key, value in LSTM(bidirectional=True).named_parameters():\n",
    "    print(f\"{key:^40}paramerters num: {np.prod(value.shape)}\")\n",
    "\n",
    "    \n",
    "print(\"{:=^80}\".format(\" 两层单向 LSTM \"))       \n",
    "for key, value in LSTM(num_layers=2).named_parameters():\n",
    "    print(f\"{key:^40}paramerters num: {np.prod(value.shape)}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-02T08:36:09.545313600Z",
     "start_time": "2024-05-02T08:36:09.506335700Z"
    },
    "collapsed": false,
    "execution": {
     "iopub.execute_input": "2025-02-04T02:57:45.515914Z",
     "iopub.status.busy": "2025-02-04T02:57:45.515605Z",
     "iopub.status.idle": "2025-02-04T02:57:45.519426Z",
     "shell.execute_reply": "2025-02-04T02:57:45.518860Z",
     "shell.execute_reply.started": "2025-02-04T02:57:45.515895Z"
    },
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4096"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "4 * 16 * 64 #lstm.weight_ih_l0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-02T08:36:14.836046500Z",
     "start_time": "2024-05-02T08:36:14.799050900Z"
    },
    "collapsed": false,
    "execution": {
     "iopub.execute_input": "2025-02-04T02:57:45.520058Z",
     "iopub.status.busy": "2025-02-04T02:57:45.519896Z",
     "iopub.status.idle": "2025-02-04T02:57:45.523754Z",
     "shell.execute_reply": "2025-02-04T02:57:45.523197Z",
     "shell.execute_reply.started": "2025-02-04T02:57:45.520040Z"
    },
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16384"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "4* 64*64 #lstm.weight_hh_l0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-02-04T02:57:45.524378Z",
     "iopub.status.busy": "2025-02-04T02:57:45.524220Z",
     "iopub.status.idle": "2025-02-04T02:57:45.552774Z",
     "shell.execute_reply": "2025-02-04T02:57:45.552300Z",
     "shell.execute_reply.started": "2025-02-04T02:57:45.524360Z"
    }
   },
   "outputs": [],
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "@torch.no_grad()\n",
    "def evaluating(model, dataloader, loss_fct):\n",
    "    loss_list = []\n",
    "    pred_list = []\n",
    "    label_list = []\n",
    "    for datas, labels in dataloader:\n",
    "        datas = datas.to(device)\n",
    "        labels = labels.to(device)\n",
    "        # 前向计算\n",
    "        logits = model(datas)\n",
    "        loss = loss_fct(logits, labels)         # 验证集损失\n",
    "        loss_list.append(loss.item())\n",
    "        # 二分类\n",
    "        preds = logits > 0\n",
    "        pred_list.extend(preds.cpu().numpy().tolist())\n",
    "        label_list.extend(labels.cpu().numpy().tolist())\n",
    "        \n",
    "    acc = accuracy_score(label_list, pred_list)\n",
    "    return np.mean(loss_list), acc\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### TensorBoard 可视化\n",
    "\n",
    "\n",
    "训练过程中可以使用如下命令启动tensorboard服务。\n",
    "\n",
    "```shell\n",
    "tensorboard \\\n",
    "    --logdir=runs \\     # log 存放路径\n",
    "    --host 0.0.0.0 \\    # ip\n",
    "    --port 8848         # 端口\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-02-04T02:57:45.553778Z",
     "iopub.status.busy": "2025-02-04T02:57:45.553298Z",
     "iopub.status.idle": "2025-02-04T02:57:45.600301Z",
     "shell.execute_reply": "2025-02-04T02:57:45.599869Z",
     "shell.execute_reply.started": "2025-02-04T02:57:45.553756Z"
    }
   },
   "outputs": [],
   "source": [
    "from torch.utils.tensorboard import SummaryWriter\n",
    "\n",
    "\n",
    "class TensorBoardCallback:\n",
    "    def __init__(self, log_dir, flush_secs=10):\n",
    "        \"\"\"\n",
    "        Args:\n",
    "            log_dir (str): dir to write log.\n",
    "            flush_secs (int, optional): write to dsk each flush_secs seconds. Defaults to 10.\n",
    "        \"\"\"\n",
    "        self.writer = SummaryWriter(log_dir=log_dir, flush_secs=flush_secs)\n",
    "\n",
    "    def draw_model(self, model, input_shape):\n",
    "        self.writer.add_graph(model, input_to_model=torch.randn(input_shape))\n",
    "        \n",
    "    def add_loss_scalars(self, step, loss, val_loss):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/loss\", \n",
    "            tag_scalar_dict={\"loss\": loss, \"val_loss\": val_loss},\n",
    "            global_step=step,\n",
    "            )\n",
    "        \n",
    "    def add_acc_scalars(self, step, acc, val_acc):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/accuracy\",\n",
    "            tag_scalar_dict={\"accuracy\": acc, \"val_accuracy\": val_acc},\n",
    "            global_step=step,\n",
    "        )\n",
    "        \n",
    "    def add_lr_scalars(self, step, learning_rate):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/learning_rate\",\n",
    "            tag_scalar_dict={\"learning_rate\": learning_rate},\n",
    "            global_step=step,\n",
    "            \n",
    "        )\n",
    "    \n",
    "    def __call__(self, step, **kwargs):\n",
    "        # add loss\n",
    "        loss = kwargs.pop(\"loss\", None)\n",
    "        val_loss = kwargs.pop(\"val_loss\", None)\n",
    "        if loss is not None and val_loss is not None:\n",
    "            self.add_loss_scalars(step, loss, val_loss)\n",
    "        # add acc\n",
    "        acc = kwargs.pop(\"acc\", None)\n",
    "        val_acc = kwargs.pop(\"val_acc\", None)\n",
    "        if acc is not None and val_acc is not None:\n",
    "            self.add_acc_scalars(step, acc, val_acc)\n",
    "        # add lr\n",
    "        learning_rate = kwargs.pop(\"lr\", None)\n",
    "        if learning_rate is not None:\n",
    "            self.add_lr_scalars(step, learning_rate)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Save Best\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-02-04T02:57:45.600933Z",
     "iopub.status.busy": "2025-02-04T02:57:45.600758Z",
     "iopub.status.idle": "2025-02-04T02:57:45.606132Z",
     "shell.execute_reply": "2025-02-04T02:57:45.605531Z",
     "shell.execute_reply.started": "2025-02-04T02:57:45.600915Z"
    }
   },
   "outputs": [],
   "source": [
    "class SaveCheckpointsCallback:\n",
    "    def __init__(self, save_dir, save_step=5000, save_best_only=True):\n",
    "        \"\"\"\n",
    "        Save checkpoints each save_epoch epoch. \n",
    "        We save checkpoint by epoch in this implementation.\n",
    "        Usually, training scripts with pytorch evaluating model and save checkpoint by step.\n",
    "\n",
    "        Args:\n",
    "            save_dir (str): dir to save checkpoint\n",
    "            save_epoch (int, optional): the frequency to save checkpoint. Defaults to 1.\n",
    "            save_best_only (bool, optional): If True, only save the best model or save each model at every epoch.\n",
    "        \"\"\"\n",
    "        self.save_dir = save_dir\n",
    "        self.save_step = save_step\n",
    "        self.save_best_only = save_best_only\n",
    "        self.best_metrics = -1\n",
    "        \n",
    "        # mkdir\n",
    "        if not os.path.exists(self.save_dir):\n",
    "            os.mkdir(self.save_dir)\n",
    "        \n",
    "    def __call__(self, step, state_dict, metric=None):\n",
    "        if step % self.save_step > 0:\n",
    "            return\n",
    "        \n",
    "        if self.save_best_only:\n",
    "            assert metric is not None\n",
    "            if metric >= self.best_metrics:\n",
    "                # save checkpoints\n",
    "                torch.save(state_dict, os.path.join(self.save_dir, \"best.ckpt\"))\n",
    "                # update best metrics\n",
    "                self.best_metrics = metric\n",
    "        else:\n",
    "            torch.save(state_dict, os.path.join(self.save_dir, f\"{step}.ckpt\"))\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Early Stop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-02-04T02:57:45.606915Z",
     "iopub.status.busy": "2025-02-04T02:57:45.606737Z",
     "iopub.status.idle": "2025-02-04T02:57:45.610924Z",
     "shell.execute_reply": "2025-02-04T02:57:45.610420Z",
     "shell.execute_reply.started": "2025-02-04T02:57:45.606896Z"
    }
   },
   "outputs": [],
   "source": [
    "class EarlyStopCallback:\n",
    "    def __init__(self, patience=5, min_delta=0.01):\n",
    "        \"\"\"\n",
    "\n",
    "        Args:\n",
    "            patience (int, optional): Number of epochs with no improvement after which training will be stopped.. Defaults to 5.\n",
    "            min_delta (float, optional): Minimum change in the monitored quantity to qualify as an improvement, i.e. an absolute \n",
    "                change of less than min_delta, will count as no improvement. Defaults to 0.01.\n",
    "        \"\"\"\n",
    "        self.patience = patience\n",
    "        self.min_delta = min_delta\n",
    "        self.best_metric = -1\n",
    "        self.counter = 0\n",
    "        \n",
    "    def __call__(self, metric):\n",
    "        if metric >= self.best_metric + self.min_delta:\n",
    "            # update best metric\n",
    "            self.best_metric = metric\n",
    "            # reset counter \n",
    "            self.counter = 0\n",
    "        else: \n",
    "            self.counter += 1\n",
    "            \n",
    "    @property\n",
    "    def early_stop(self):\n",
    "        return self.counter >= self.patience\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-02-04T02:57:45.611864Z",
     "iopub.status.busy": "2025-02-04T02:57:45.611467Z",
     "iopub.status.idle": "2025-02-04T02:57:46.637281Z",
     "shell.execute_reply": "2025-02-04T02:57:46.636768Z",
     "shell.execute_reply.started": "2025-02-04T02:57:45.611844Z"
    }
   },
   "outputs": [],
   "source": [
    "# 训练\n",
    "def training(\n",
    "    model, \n",
    "    train_loader, \n",
    "    val_loader, \n",
    "    epoch, \n",
    "    loss_fct, \n",
    "    optimizer, \n",
    "    tensorboard_callback=None,\n",
    "    save_ckpt_callback=None,\n",
    "    early_stop_callback=None,\n",
    "    eval_step=500,\n",
    "    ):\n",
    "    record_dict = {\n",
    "        \"train\": [],\n",
    "        \"val\": []\n",
    "    }\n",
    "    \n",
    "    global_step = 0\n",
    "    model.train()\n",
    "    with tqdm(total=epoch * len(train_loader)) as pbar:\n",
    "        for epoch_id in range(epoch):\n",
    "            # training\n",
    "            for datas, labels in train_loader:\n",
    "                datas = datas.to(device)\n",
    "                labels = labels.to(device)\n",
    "                # 梯度清空\n",
    "                optimizer.zero_grad()\n",
    "                # 模型前向计算\n",
    "                logits = model(datas)\n",
    "                # 计算损失\n",
    "                loss = loss_fct(logits, labels)\n",
    "                # 梯度回传\n",
    "                loss.backward()\n",
    "                # 调整优化器，包括学习率的变动等\n",
    "                optimizer.step()\n",
    "                preds = logits > 0\n",
    "            \n",
    "                acc = accuracy_score(labels.cpu().numpy(), preds.cpu().numpy())    \n",
    "                loss = loss.cpu().item()\n",
    "                # record\n",
    "                \n",
    "                record_dict[\"train\"].append({\n",
    "                    \"loss\": loss, \"acc\": acc, \"step\": global_step\n",
    "                })\n",
    "                \n",
    "                # evaluating\n",
    "                if global_step % eval_step == 0:\n",
    "                    model.eval()\n",
    "                    val_loss, val_acc = evaluating(model, val_loader, loss_fct)\n",
    "                    record_dict[\"val\"].append({\n",
    "                        \"loss\": val_loss, \"acc\": val_acc, \"step\": global_step\n",
    "                    })\n",
    "                    model.train()\n",
    "                    \n",
    "                    # 1. 使用 tensorboard 可视化\n",
    "                    if tensorboard_callback is not None:\n",
    "                        tensorboard_callback(\n",
    "                            global_step, \n",
    "                            loss=loss, val_loss=val_loss,\n",
    "                            acc=acc, val_acc=val_acc,\n",
    "                            lr=optimizer.param_groups[0][\"lr\"],\n",
    "                            )\n",
    "                \n",
    "                    # 2. 保存模型权重 save model checkpoint\n",
    "                    if save_ckpt_callback is not None:\n",
    "                        save_ckpt_callback(global_step, model.state_dict(), metric=val_acc)\n",
    "\n",
    "                    # 3. 早停 Early Stop\n",
    "                    if early_stop_callback is not None:\n",
    "                        early_stop_callback(val_acc)\n",
    "                        if early_stop_callback.early_stop:\n",
    "                            print(f\"Early stop at epoch {epoch_id} / global_step {global_step}\")\n",
    "                            return record_dict\n",
    "                    \n",
    "                # udate step\n",
    "                global_step += 1\n",
    "                pbar.update(1)\n",
    "                pbar.set_postfix({\"epoch\": epoch_id})\n",
    "        \n",
    "    return record_dict\n",
    "        \n",
    "\n",
    "epoch = 20\n",
    "\n",
    "model = LSTM()\n",
    "\n",
    "# 1. 定义损失函数 采用交叉熵损失 (但是二分类)\n",
    "loss_fct = F.binary_cross_entropy_with_logits\n",
    "# 2. 定义优化器 采用 adam\n",
    "# Optimizers specified in the torch.optim package\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=0.001)\n",
    "\n",
    "# 1. tensorboard 可视化\n",
    "if not os.path.exists(\"runs\"):\n",
    "    os.mkdir(\"runs\")\n",
    "tensorboard_callback = TensorBoardCallback(\"runs/imdb-lstm\")\n",
    "# tensorboard_callback.draw_model(model, [1, MAX_LENGTH])\n",
    "# 2. save best\n",
    "if not os.path.exists(\"checkpoints\"):\n",
    "    os.makedirs(\"checkpoints\")\n",
    "save_ckpt_callback = SaveCheckpointsCallback(\"checkpoints/imdb-lstm\", save_step=len(train_dl), save_best_only=True)\n",
    "# 3. early stop\n",
    "early_stop_callback = EarlyStopCallback(patience=10)\n",
    "\n",
    "\n",
    "# 如果有可用的多个GPU\n",
    "if torch.cuda.device_count() > 1:\n",
    "    print(\"使用多个GPU进行训练...\")\n",
    "    model = nn.DataParallel(model)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-02-04T02:57:46.638338Z",
     "iopub.status.busy": "2025-02-04T02:57:46.637914Z",
     "iopub.status.idle": "2025-02-04T03:00:30.691445Z",
     "shell.execute_reply": "2025-02-04T03:00:30.690796Z",
     "shell.execute_reply.started": "2025-02-04T02:57:46.638314Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 3920/3920 [02:43<00:00, 23.91it/s, epoch=19]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "use time163.9779326915741\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "model = model.to(device)\n",
    "start=time.time()\n",
    "record = training(\n",
    "    model, \n",
    "    train_dl, \n",
    "    test_dl, \n",
    "    epoch, \n",
    "    loss_fct, \n",
    "    optimizer, \n",
    "    tensorboard_callback=tensorboard_callback,\n",
    "    save_ckpt_callback=save_ckpt_callback,\n",
    "    early_stop_callback=early_stop_callback,\n",
    "    eval_step=len(train_dl)\n",
    "    )\n",
    "end=time.time()\n",
    "print(f'use time{end-start}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-02-04T03:00:30.692287Z",
     "iopub.status.busy": "2025-02-04T03:00:30.692082Z",
     "iopub.status.idle": "2025-02-04T03:00:30.885091Z",
     "shell.execute_reply": "2025-02-04T03:00:30.884610Z",
     "shell.execute_reply.started": "2025-02-04T03:00:30.692265Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#画线要注意的是损失是不一定在零到1之间的\n",
    "def plot_learning_curves(record_dict, sample_step=500):\n",
    "    # build DataFrame\n",
    "    train_df = pd.DataFrame(record_dict[\"train\"]).set_index(\"step\").iloc[::sample_step]\n",
    "    val_df = pd.DataFrame(record_dict[\"val\"]).set_index(\"step\")\n",
    "\n",
    "    # plot\n",
    "    fig_num = len(train_df.columns)\n",
    "    fig, axs = plt.subplots(1, fig_num, figsize=(5 * fig_num, 5))\n",
    "    for idx, item in enumerate(train_df.columns):    \n",
    "        axs[idx].plot(train_df.index, train_df[item], label=f\"train_{item}\")\n",
    "        axs[idx].plot(val_df.index, val_df[item], label=f\"val_{item}\")\n",
    "        axs[idx].grid()\n",
    "        axs[idx].legend()\n",
    "        # axs[idx].set_xticks(range(0, train_df.index[-1], 5000))\n",
    "        # axs[idx].set_xticklabels(map(lambda x: f\"{int(x/1000)}k\", range(0, train_df.index[-1], 5000)))\n",
    "        axs[idx].set_xlabel(\"step\")\n",
    "    \n",
    "    plt.show()\n",
    "\n",
    "plot_learning_curves(record, sample_step=10)  #横坐标是 steps"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 评估"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-02-04T03:00:30.885814Z",
     "iopub.status.busy": "2025-02-04T03:00:30.885626Z",
     "iopub.status.idle": "2025-02-04T03:00:34.581664Z",
     "shell.execute_reply": "2025-02-04T03:00:34.581135Z",
     "shell.execute_reply.started": "2025-02-04T03:00:30.885794Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_910/1661179837.py:4: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n",
      "  model.load_state_dict(torch.load(\"checkpoints/imdb-lstm/best.ckpt\", map_location=\"cpu\"))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss:     0.3510\n",
      "accuracy: 0.8675\n"
     ]
    }
   ],
   "source": [
    "# dataload for evaluating\n",
    "\n",
    "# load checkpoints\n",
    "model.load_state_dict(torch.load(\"checkpoints/imdb-lstm/best.ckpt\", map_location=\"cpu\"))\n",
    "\n",
    "model.eval()\n",
    "loss, acc = evaluating(model, test_dl, loss_fct)\n",
    "print(f\"loss:     {loss:.4f}\\naccuracy: {acc:.4f}\")"
   ]
  }
 ],
 "metadata": {
  "kaggle": {
   "accelerator": "nvidiaTeslaT4",
   "dataSources": [],
   "isGpuEnabled": true,
   "isInternetEnabled": true,
   "language": "python",
   "sourceType": "notebook"
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
